﻿#define  _CRT_SECURE_NO_WARNINGS 1

//int foo(int n) 
//{
//	if (n < 2)
//	{
//		return n;
//	}
//	else
//		return 2 * foo(n - 1) + foo(n - 2);
//}






//关于C语言，下列指针变量的定义和解释，均正确的是（）
//A
//int* p[10]; //定义10个指针变量组成的指针数组
//B
//int* p(); //定义一个函数的指针，将来可用此指针指向一个函数
//C
//int(*p)[]; //定义一个行指针
//D
//int** p; //定义一个指针变量，该指针变量可以指一个向二维数组



//
//哪个操作符不能作为类成员函数被重载？
//A
//? ：
//B
//++
//C
//[]
//D
//==
//E
//*




//
//
//printf("%5s", "abcdefg");




//
//设有以下函数
//int f(int a, char* b) { „„ }
//则下面对函数指针的定义和赋值错误的是（ ）
//A
//int (*p)(int, char*); p = f;
//B
//int* p(); p = f;
//C
//int(*)p(); p = &f;
//D
//int* p(int, char); p = &f;





//#include<stdio.h>
//int main()
//{
//	float n = 1.234567;
//	printf("%.5f",n);
//	return 0;
//}
//





//
//2.
//若所用变量都已正确定义，以下选项中，非法的表达式是（）
//A
//a != 4 || b == 1
//B
//’a’ % 3
//C
//’a’ = 1 / 3
//D
//’A’ + 32





//
//
//"My salary was increased by 15%!"
//下列哪个选项可以准确的显示出上述语句？
//A
//printf("\"My salary was increased by 15/%\!\"\n");
//B
//printf("My salary was increased by 15%!\n");
//C
//printf("My salary was increased by 15'%'!\n");
//D
//printf("\"My salary was increased by 15%%!\"\n");






//struct stu 
//{
//    union 
//    {
//        char bj[5];
//        int bh[2];
//    } _class;
//    char xm[8];
//    float cj;
//}xc;




//int countStudents(int* students, int studentsSize, int* sandwiches, int sandwichesSize)
//{
//    int i = 0;
//    while (i != studentsSize)
//    {
//        if (students[0] == sandwiches[0])
//        {
//            for (int k = 1; k < studentsSize; k++)
//            {
//                students[k - 1] = students[k];
//            }
//            for (int k = 1; k < sandwichesSize; k++)
//            {
//                sandwiches[k - 1] = sandwiches[k];
//            }
//            sandwichesSize--;
//            studentsSize--;
//            i = 0;
//        }
//        else
//        {
//            int tmp = students[0];
//            for (int k = 1; k < studentsSize; k++)
//            {
//                students[k - 1] = students[k];
//            }
//            students[studentsSize - 1] = tmp;
//            i++;
//        }
//    }
//    return sandwichesSize;
//
//}

//
//int* twoOutOfThree(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* returnSize)
//{
//    int sum = 0;
//    int count = 0;
//    int* tmp = (int*)malloc(sizeof(int) * 100);
//    int pos = 0;
//    for (int i = 0; i < nums1Size; i++)
//    {
//        count = 0;
//        for (int k = 0; k < nums2Size; k++)
//        {
//            if (nums2[k] == nums1[i])
//            {
//                count++;
//            }
//        }
//        for (int m = 0; m < nums3Size; m++)
//        {
//            if (nums3[m] == nums1[i])
//            {
//                count++;
//            }
//        }
//        if (count >= 1)
//        {
//            int flag = 0;
//            for (int n = 0; n < pos; n++)
//            {
//                if (tmp[n] == nums1[i])
//                {
//                    flag = 1;
//                }
//            }
//            if (flag == 0)
//            {
//                tmp[pos++] = nums1[i];
//                sum++;
//            }
//        }
//    }
//    for (int i = 0; i < nums2Size; i++)
//    {
//        count = 0;
//        for (int k = 0; k < nums1Size; k++)
//        {
//            if (nums1[k] == nums2[i])
//            {
//                count++;
//            }
//        }
//        for (int m = 0; m < nums3Size; m++)
//        {
//            if (nums3[m] == nums2[i])
//            {
//                count++;
//            }
//        }
//        if (count >= 1)
//        {
//            int flag = 0;
//            for (int n = 0; n < pos; n++)
//            {
//                if (tmp[n] == nums2[i])
//                {
//                    flag = 1;
//                }
//            }
//            if (flag == 0)
//            {
//                tmp[pos++] = nums2[i];
//                sum++;
//            }
//        }
//    }
//    *returnSize = sum;
//    return tmp;
//}

//
//
//
//int min(int x, int y)
//{
//    return x < y ? x : y;
//}
//int max(int x, int y)
//{
//    return x > y ? x : y;
//}
//int main()
//{
//    int nums[4] = { 70, 38, 21, 22 };
//    int numsSize = 4;
//    while (numsSize != 1)
//    {
//        int k = 0;
//        int n = numsSize / 2;
//        for (int i = 1; i < numsSize; i += n)
//        {
//            nums[k++] = min(nums[i - 1], nums[i]);
//        }
//        for (int i = numsSize / n + 1; i < numsSize; i += n)
//        {
//            nums[k++] = max(nums[i - 1], nums[i]);
//        }
//        numsSize /= 2;
//    }
//    return nums[0];
//}
//
//
//int min(int x, int y)
//{
//    return x < y ? x : y;
//}
//int max(int x, int y)
//{
//    return x > y ? x : y;
//}
//int minMaxGame(int* nums, int numsSize)
//{
//    while (numsSize != 1)
//    {
//        int k = 0;
//        for (int i = 0; i < numsSize / 2; i++)
//        {
//            if (i % 2 == 0)
//            {
//                nums[k++] = min(nums[2 * i], nums[2 * i + 1]);
////            }
////            else
////            {
////                nums[k++] = max(nums[2 * i], nums[2 * i + 1]);
////            }
////        }
////        numsSize /= 2;
////    }
////    return nums[0];
////
////}
//int max(int x, int y)
//{
//    return x > y ? x : y;
//}
//int minStartValue(int* nums, int numsSize)
//{
//    int flag = 0;
//    int sum = 0;
//    int startValue = 1;
//    while (flag != 1)
//    {
//        flag = 1;
//        sum = startValue;
//        for (int i = 0; i < numsSize; i++)
//        {
//            sum += nums[i];
//            if (sum < 1)
//            {
//                flag = 0;
//                break;
//            }
//        }
//        if (flag == 0)
//        {
//            startValue++;
//        }
//    }
//    return startValue;
//}


//
//int cmp(const void* p1, const void* p2)
//{
//    return *(int*)p1 - *(int*)p2;
//}
//int** minimumAbsDifference(int* arr, int arrSize, int* returnSize, int** returnColumnSizes)
//{
//    qsort(arr, arrSize, sizeof(int), cmp);
//    int** res = (int**)malloc(sizeof(int*) * arrSize);
//    for (int i = 0; i < arrSize; i++)
//    {
//        res[i] = malloc(sizeof(int) * 2);
//    }
//    int min = 10000;
//    for (int i = 1; i < arrSize; i++)
//    {
//        if (abs(arr[i] - arr[i - 1]) < min)
//        {
//            min = arr[i] - arr[i - 1];
//        }
//    }
//    int count = 0;
//    int k = 0;
//    for (int i = 1; i < arrSize; i++)
//    {
//        if (abs(arr[i] - arr[i - 1]) == min)
//        {
//            res[k][0] = arr[i - 1];
//            res[k++][1] = arr[i];
//            count++;
//        }
//    }
//    *returnSize = count;
//    *returnColumnSizes = malloc(sizeof(int) * count);
//    for (int i = 0; i < count; i++)
//    {
//        (*returnColumnSizes)[i] = 2;
//    }
//    return res;
//}
//
//
//int maxDistance(int* colors, int colorsSize)
//{
//    int max = 0;
//    for (int i = 0; i < colorsSize; i++)
//    {
//        for (int j = i + 1; j < colorsSize; j++)
//        {
//            if (colors[i] != colors[j])
//            {
//                int tmp = j - i;
//                if ((tmp) > max)
//                {
//                    max = tmp;
//                }
//            }
//        }
//    }
//    return max;
//}






////int singleNumber(int* nums, int numsSize)
////{
////    int count = 0;
////    int tmp = 0;
////    for (int i = 0; i < numsSize; i++)
////    {
////        count = 0;
////        for (int j = i + 1; j < numsSize; j++)
////        {
////            if (nums[i] == nums[j])
////            {
////                nums[i] = nums[j] = -100;
////                count++;
////            }
////        }
////        if (count == 0 && nums[i] != -100)
////        {
////            tmp = nums[i];
////            return tmp;
////        }
////    }
////    return tmp;
////}
////


































